弹力设计篇之"服务的状态" - [2026重制版]

# deployment-stateless.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
  labels:
    app: order-service
spec:
  replicas: 3  # 运行3个副本，完全无状态
  selector:
    matchLabels:
      app: order-service
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1          # 滚动更新时最多多出1个Pod
      maxUnavailable: 0   # 不允许不可用
  template:
    metadata:
      labels:
        app: order-service
    spec:
      serviceAccountName: order-service-sa
      securityContext:
        runAsNonRoot: true
        runAsUser: 1000
        fsGroup: 1000
      containers:
      - name: order-service
        image: order-service:v2.3.0
        ports:
        - containerPort: 8080
          protocol: TCP
        env:
        # 从ConfigMap读取配置（无硬编码）
        - name: SPRING_PROFILES_ACTIVE
          valueFrom:
            configMapKeyRef:
              name: order-service-config
              key: spring.profiles.active
        # 从Secret读取敏感信息
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: database-secret
              key: url
        # 资源限制（防止资源争抢）
        resources:
          requests:
            cpu: 100m
            memory: 256Mi
          limits:
            cpu: "1"
            memory: 512Mi
        # 健康检查
        livenessProbe:
          httpGet:
            path: /actuator/health/liveness
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
          timeoutSeconds: 3
          failureThreshold: 3
        startupProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 5
          failureThreshold: 30  # 允许最长150秒启动时间
        # 安全上下文
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          capabilities:
            drop:
            - ALL
        volumeMounts:
        - name: tmp
          mountPath: /tmp
        - name: logs
          mountPath: /var/log/app
      volumes:
      - name: tmp
        emptyDir: {}
      - name: logs
        emptyDir: {}
      # 优雅终止
      terminationGracePeriodSeconds: 30  # 允许30秒完成正在处理的请求
---
# 对应的Service（负载均衡器）
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  type: ClusterIP
  selector:
    app: order-service
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP

# statefulset-mongodb.yaml
# MongoDB副本集的有状态部署
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongodb
  labels:
    app: mongodb
spec:
  serviceName: mongodb-headless  # 必须关联Headless Service
  replicas: 3                   # 3节点副本集
  selector:
    matchLabels:
      app: mongodb
  template:
    metadata:
      labels:
        app: mongodb
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: mongodb
        image: mongo:6.0
        command:
        - mongod
        - --wiredTigerCacheSizeGB
        - "0.5"
        - --bind_ip
        - "0.0.0.0"
        - --replSet
        - rs0
        ports:
        - containerPort: 27017
          name: peer
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name  # 获取Pod序号(0,1,2)
        volumeMounts:
        - name: data
          mountPath: /data/db       # 数据持久化目录
        - name: config
          mountPath: /config
          readOnly: true
        resources:
          requests:
            cpu: 500m
            memory: 1Gi
          limits:
            cpu: "2"
            memory: 4Gi
        readinessProbe:
          exec:
            command:
            - mongo
            - --eval
            - "db.adminCommand('ping')"
          initialDelaySeconds: 10
          periodSeconds: 10
        livenessProbe:
          exec:
            command:
            - mongo
            - --eval
            - "db.adminCommand('ping')"
          initialDelaySeconds: 30
          periodSeconds: 20
  volumeClaimTemplates:           # ⭐ 关键：自动为每个Pod创建PVC
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      storageClassName: standard   # 使用GP2 SSD
      resources:
        requests:
          storage: 100Gi           # 每个MongoDB节点100GB
  volumes:
  - name: config
    configMap:
      name: mongodb-config
---
# Headless Service（用于稳定的网络标识）
apiVersion: v1
kind: Service
metadata:
  name: mongodb-headless
  labels:
    app: mongodb
spec:
  clusterIP: None                 # Headless Service
  selector:
    app: mongodb
  ports:
  - name: peer
    port: 27017
    targetPort: 27017
---
# 普通Service（用于客户端访问）
apiVersion: v1
kind: Service
metadata:
  name: mongodb
spec:
  selector:
    app: mongodb
  ports:
  - port: 27017
    targetPort: 27017

// Maven依赖
/*
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
*/

@Configuration
@EnableRedisHttpSession  // 启用Redis HTTP Session
public class SessionConfig {

    /**
     * 配置Redis序列化器（使用JSON而非Java默认序列化）
     */
    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }

    /**
     * Cookie配置
     */
    @Bean
    public CookieSerializer cookieSerializer() {
        DefaultCookieSerializer serializer = new DefaultCookieSerializer();
        serializer.setCookieName("SESSION_ID");     // Cookie名称
        serializer.setUseHttpOnly(true);             // 防止XSS攻击
        serializer.setSameSite("Lax");               // CSRF保护
        serializer.setDomainNamePattern("^.+?\\.\\..*"); // 匹配所有子域
        serializer.setCookiePath("/");                // 全站有效
        serializer.setMaxAge(Duration.ofHours(24));   // 过期时间
        return serializer;
    }
}

// Controller中使用Session
@RestController
@RequestMapping("/api/cart")
@RequiredArgsConstructor
public class ShoppingCartController {

    private final ShoppingCartService cartService;

    /**
     * 购物车是无状态的典型反面教材！
     * 但使用Spring Session后，购物车数据存在Redis中，
     * 服务本身仍然是无状态的。
     */
    @GetMapping
    public ResponseEntity<CartResponse> getCart(HttpSession session) {
        String userId = (String) session.getAttribute("userId");
        
        // 如果用户未登录，从Session获取临时购物车ID
        String cartId = (String) session.getAttribute("cartId");
        if (cartId == null) {
            cartId = UUID.randomUUID().toString();
            session.setAttribute("cartId", cartId);
        }

        CartResponse cart = cartService.getCart(cartId);
        return ResponseEntity.ok(cart);
    }

    @PostMapping("/items")
    public ResponseEntity<Void> addItem(
            @RequestBody AddCartItemRequest request,
            HttpSession session) {
        
        String cartId = (String) session.getAttribute("cartId");
        cartService.addItem(cartId, request.getProductId(), request.getQuantity());
        
        return ResponseEntity.ok().build();
    }
}

@Service
@RequiredArgsConstructor
@Slf4j
public class JwtTokenService {

    private final JwtProperties properties;
    private final RSAKey rsaKey;

    @PostConstruct
    public void init() throws Exception {
        // 加载RSA密钥对（用于RS256签名）
        KeyFactory kf = KeyFactory.getInstance("RSA");
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(
            Base64.getDecoder().decode(properties.getPrivateKey())
        );
        this.rsaKey = new RSAPrivateKey(kf.generatePrivate(keySpec));
    }

    /**
     * 生成JWT Token
     */
    public String generateToken(Authentication authentication) {
        UserPrincipal userPrincipal = (UserPrincipal) authentication.getPrincipal();

        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + properties.getTokenValidityInSeconds() * 1000);

        return Jwts.builder()
            .setSubject(Long.toString(userPrincipal.getId()))
            .setIssuedAt(new Date())
            .setExpiration(expiryDate)
            .claim("email", userPrincipal.getEmail())
            .claim("roles", userPrincipal.getAuthorities()
                .stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()))
            .signWith(rsaKey, SignatureAlgorithm.RS256)  // 非对称加密
            .compact();
    }

    /**
     * 从Token中获取用户ID（无需查询数据库）
     */
    public Long getUserIdFromToken(String token) {
        Claims claims = Jwts.parserBuilder()
            .setSigningKey(getPublicKey())
            .build()
            .parseClaimsJws(token)
            .getBody();

        return Long.parseLong(claims.getSubject());
    }

    /**
     * 验证Token有效性
     */
    public boolean validateToken(String authToken) {
        try {
            Jwts.parserBuilder()
                .setSigningKey(getPublicKey())
                .build()
                .parseClaimsJws(authToken);
            return true;
        } catch (SecurityException ex) {
            log.error("Invalid JWT signature");
        } catch (MalformedJwtException ex) {
            log.error("Invalid JWT token");
        } catch (ExpiredJwtException ex) {
            log.error("Expired JWT token");
        } catch (UnsupportedJwtException ex) {
            log.error("Unsupported JWT token");
        } catch (IllegalArgumentException ex) {
            log.error("JWT claims string is empty.");
        }
        return false;
    }
}

/**
 * 用户偏好设置服务（展示如何将状态外置）
 * 
 * 场景：用户的UI主题、语言偏好等需要跨请求保持，
 * 但不应该保存在应用内存中。
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class UserPreferenceService {

    private final RedisTemplate<String, String> redisTemplate;
    private final UserRepository userRepository;
    
    private static final String PREFERENCE_KEY_PREFIX = "user:pref:";
    private static final Duration CACHE_TTL = Duration.ofHours(24);

    /**
     * 获取用户偏好（优先从缓存读取）
     */
    public UserPreference getPreference(Long userId) {
        String key = PREFERENCE_KEY_PREFIX + userId;
        
        // 1. 先查Redis缓存
        String cached = redisTemplate.opsForValue().get(key);
        if (cached != null) {
            log.debug("Cache hit for user preference: {}", userId);
            return JsonUtils.fromJson(cached, UserPreference.class);
        }

        // 2. 缓存未命中，查数据库
        UserPreference preference = userRepository.findPreferenceByUserId(userId)
            .orElse(UserPreference.defaultPreference());

        // 3. 写入缓存（异步，不影响响应时间）
        CompletableFuture.runAsync(() -> {
            redisTemplate.opsForValue().set(
                key, 
                JsonUtils.toJson(preference), 
                CACHE_TTL
            );
        });

        return preference;
    }

    /**
     * 更新用户偏好（同时更新DB和Cache）
     */
    @Transactional
    public void updatePreference(Long userId, UpdatePreferenceRequest request) {
        // 1. 更新数据库（强一致）
        userRepository.updatePreference(userId, request);

        // 2. 删除缓存（下次访问时重新加载）
        String key = PREFERENCE_KEY_PREFIX + userId;
        redisTemplate.delete(key);

        // 3. 发布事件（通知其他服务）
        eventPublisher.publishEvent(new PreferenceChangedEvent(userId, request));
    }
}

/**
 * 购物车服务（更复杂的例子：需要处理并发）
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class ShoppingCartService {

    private final RedisTemplate<String, Object> redisTemplate;
    private final CartEventPublisher eventPublisher;

    private static final String CART_KEY_PREFIX = "cart:";
    private static final Duration CART_TTL = Duration.ofDays(7);  // 购物车保留7天

    /**
     * 添加商品到购物车（使用Redis Hash结构）
     * 
     * 为什么用Redis而不是数据库？
     * - 购物车是临时数据，不需要持久化
     * - 需要高频读写（每次浏览商品页可能触发）
     * - 支持原子操作（避免超卖）
     */
    public CartItem addToCart(String cartId, String productId, int quantity) {
        String key = CART_KEY_PREFIX + cartId;

        // 使用Lua脚本保证原子性：
        // 1. 检查是否已存在该商品
        // 2. 如果存在则增加数量，否则新增
        // 3. 返回最新的数量
        String luaScript =
            "local current = redis.call('HGET', KEYS[1], ARGV[1]) " +
            "if current then " +
            "   local newQty = tonumber(current) + tonumber(ARGV[2]) " +
            "   redis.call('HSET', KEYS[1], ARGV[1], newQty) " +
            "   return newQty " +
            "else " +
            "   redis.call('HSET', KEYS[1], ARGV[1], ARGV[2]) " +
            "   return tonumber(ARGV[2]) " +
            "end";

        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
        script.setScriptText(luaScript);
        script.setResultType(Long.class);

        Long newQuantity = redisTemplate.execute(
            script,
            Collections.singletonList(key),
            productId,
            String.valueOf(quantity)
        );

        // 刷新过期时间（滑动过期）
        redisTemplate.expire(key, CART_TTL);

        // 发布事件用于数据分析
        eventPublisher.publishCartUpdated(cartId, productId, newQuantity);

        return CartItem.builder()
            .productId(productId)
            .quantity(newQuantity)
            .build();
    }

    /**
     * 获取完整购物车
     */
    public Map<String, Integer> getCartItems(String cartId) {
        String key = CART_KEY_PREFIX + cartId;
        Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
        
        return entries.entrySet().stream()
            .collect(Collectors.toMap(
                e -> (String) e.getKey(),
                e -> (Integer) e.getValue()
            ));
    }

    /**
     * 清空购物车（下单成功后调用）
     */
    public void clearCart(String cartId) {
        String key = CART_KEY_PREFIX + cartId;
        redisTemplate.delete(key);
        log.info("Cleared shopping cart: {}", cartId);
    }
}

// 引入Spring Session
@EnableRedisHttpSession
public class SessionConfig { ... }

// 问题解决：
// ✅ 可以水平扩展了
// ✅ 多个实例共享Session
// ❌ Redis单点故障风险

用户 → API Gateway (验证JWT) → 业务服务 (无状态)

优势：
✅ 完全无状态，可无限扩展
✅ 服务间调用通过JWT传递身份
✅ Gateway统一认证，业务服务零感知

挑战：
⚠️ Token无法主动撤销（需要黑名单）
⚠️ Token较大，增加网络开销
⚠️ 敏感信息不应放入JWT

# AWS Lambda 示例 (Python)
import json
import boto3
from aws_lambda_powertools import Logger, Tracer

logger = Logger()
tracer = Tracer()

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('user-preferences')

@tracer.capture_lambda_handler
@logger.inject_lambda_context
def get_user_preference(event, context):
    """
    Lambda函数必须是无状态的！
    所有状态都存储在外部（DynamoDB/S3等）
    """
    user_id = event['pathParameters']['userId']
    
    # 从DynamoDB读取状态（不是内存变量！）
    response = table.get_item(Key={'userId': user_id})
    
    if 'Item' not in response:
        return {
            'statusCode': 404,
            'body': json.dumps({'error': 'User not found'})
        }
    
    preference = response['Item']
    
    return {
        'statusCode': 200,
        'body': json.dumps(preference),
        'headers': {
            'Content-Type': 'application/json',
            # 即使是同一个用户，也可能在不同容器执行
            # 所以不能假设任何本地状态存在
        }
    }